home *** CD-ROM | disk | FTP | other *** search
/ ShareWare OnLine 2 / ShareWare OnLine Volume 2 (CMS Software)(1993).iso / prog / cl182.zip / CL.HPF < prev    next >
Text File  |  1993-05-15  |  16KB  |  662 lines
  1. /*
  2.     cl.hpf -- Container Lite v 1.82 "form template"
  3.     (C) Copyright 1993  John Webster Small
  4.     All rights reserved
  5. */
  6.  
  7.  
  8. #ifndef   cl_hpp
  9. #include "cl.hpp"
  10. #endif
  11.  
  12. #ifndef string_h
  13.     #include <string.h>
  14.     #define string_h
  15. #endif
  16.  
  17.  
  18. /*  ITEM descriptors  */
  19.  
  20. #if defined(ITEM_BINARY_STRM)
  21.     #if !defined(ITEM_BINARY_STRM_INSERT)
  22.         #define ITEM_BINARY_STRM_INSERT
  23.     #endif
  24.     #if !defined(ITEM_BINARY_STRM_EXTRACT)
  25.         #define ITEM_BINARY_STRM_EXTRACT
  26.     #endif
  27. #endif
  28.  
  29. #if defined(ITEM_BINARY_CMP_STRM)
  30.     #if !defined(ITEM_BINARY_CMP)
  31.         #define ITEM_BINARY_CMP
  32.     #endif
  33.     #if !defined(ITEM_BINARY_STRM_INSERT)
  34.         #define ITEM_BINARY_STRM_INSERT
  35.     #endif
  36.     #if !defined(ITEM_BINARY_STRM_EXTRACT)
  37.         #define ITEM_BINARY_STRM_EXTRACT
  38.     #endif
  39. #endif
  40.  
  41. #if defined(ITEM_NO_STRM_OPS)
  42.     #if !defined(ITEM_NO_STRM_INSERT)
  43.         #define ITEM_NO_STRM_INSERT
  44.     #endif
  45.     #if !defined(ITEM_NO_STRM_EXTRACT)
  46.         #define ITEM_NO_STRM_EXTRACT
  47.     #endif
  48. #endif
  49.  
  50. #if defined(ITEM_NO_REL_STRM_OPS)
  51.     #if !defined(ITEM_NO_REL_OPS)
  52.         #define ITEM_NO_REL_OPS
  53.     #endif
  54.     #if !defined(ITEM_NO_STRM_INSERT)
  55.         #define ITEM_NO_STRM_INSERT
  56.     #endif
  57.     #if !defined(ITEM_NO_STRM_EXTRACT)
  58.         #define ITEM_NO_STRM_EXTRACT
  59.     #endif
  60. #endif
  61.  
  62. #if defined(ITEM_DELETE_ONLY)
  63.     #if !defined(ITEM_NO_REL_OPS)
  64.         #define ITEM_NO_REL_OPS
  65.     #endif
  66.     #if !defined(ITEM_NO_ASSIGN)
  67.         #define ITEM_NO_ASSIGN
  68.     #endif
  69.     #if !defined(ITEM_NO_COPYINIT)
  70.         #define ITEM_NO_COPYINIT
  71.     #endif
  72.     #if !defined(ITEM_NO_STRM_INSERT)
  73.         #define ITEM_NO_STRM_INSERT
  74.     #endif
  75.     #if !defined(ITEM_NO_STRM_EXTRACT)
  76.         #define ITEM_NO_STRM_EXTRACT
  77.     #endif
  78. #endif
  79.  
  80. #if defined(ITEM_BIND_ONLY)
  81.     #if !defined(ITEM_NO_REL_OPS)
  82.         #define ITEM_NO_REL_OPS
  83.     #endif
  84.     #if !defined(ITEM_NO_ASSIGN)
  85.         #define ITEM_NO_ASSIGN
  86.     #endif
  87.     #if !defined(ITEM_NO_COPYINIT)
  88.         #define ITEM_NO_COPYINIT
  89.     #endif
  90.     #if !defined(ITEM_NO_DELETE)
  91.         #define ITEM_NO_DELETE
  92.     #endif
  93.     #if !defined(ITEM_NO_STRM_INSERT)
  94.         #define ITEM_NO_STRM_INSERT
  95.     #endif
  96.     #if !defined(ITEM_NO_STRM_EXTRACT)
  97.         #define ITEM_NO_STRM_EXTRACT
  98.     #endif
  99. #endif
  100.  
  101.  
  102. #if defined(ITEM_STRMABLE) || defined(ITEM_STRM_BASE)
  103.     #if !defined(ITEM_STRM_BASE)
  104.         #define ITEM_STRM_BASE ITEM_STRMABLE
  105.     #endif
  106.     #if !defined(ITEM_TEST_ASSIGN)
  107.         #define ITEM_TEST_ASSIGN
  108.     #endif
  109.     #if !defined(ITEM_CLONE)
  110.         #define ITEM_CLONE
  111.     #endif
  112.     #if !defined(ITEM_STRM_MUT_DELETE)
  113.         #define ITEM_STRM_MUT_DELETE
  114.     #endif
  115.     #if !defined(ITEM_LINK)
  116.         #define ITEM_LINK
  117.     #endif
  118.     #if !defined(ITEM_UNLINK)
  119.         #define ITEM_UNLINK
  120.     #endif
  121.     #if !defined(ITEM_STRM_INSERT)
  122.         #define ITEM_STRM_INSERT
  123.     #endif
  124.     #if !defined(ITEM_STRM_EXTRACT)
  125.         #define ITEM_STRM_EXTRACT
  126.     #endif
  127. #endif
  128.  
  129. #if defined(ITEM_str)
  130.     #if defined(ITEM)
  131.         #undef ITEM
  132.     #endif
  133.     #define ITEM char
  134.     #if !defined(CL)
  135.         #define CL CL_str
  136.     #endif
  137. #endif
  138.  
  139.  
  140. #if defined(ITEM_NO_REL_OPS)
  141.  
  142. inline CLcmP(CL_DcmP(CLcmP(cmP,ITEM)),void)
  143. { return CLcmPcast(cmP,void); }
  144.  
  145. #else
  146.  
  147.   #if defined(ITEM_str)
  148.     // not really inline - gimmick to
  149.     // define function in header!
  150.     inline
  151.     int CL_Dcmp(const char * D1, const char * D2)
  152.     { return strcmp(D1,D2); }
  153.   #elif defined(ITEM_BINARY_CMP)
  154.     #include <string.h>    // memcmp()
  155.     // not really inline - gimmick to
  156.     // define function in header!
  157.     inline
  158.     int CL_Dcmp(const ITEM * D1, const ITEM * D2)
  159.     { return memcmp(D1,D2,sizeof(ITEM)); }
  160.   #elif !defined(ITEM_CMP_DEF)
  161.     // not really inline - gimmick to
  162.     // define function in header!
  163.     inline
  164.     int CL_Dcmp(const ITEM * D1, const ITEM * D2)
  165.     { return ((*D1 == *D2)? 0 : ((*D1 > *D2)? 1 : -1)); }
  166.   #endif
  167.  
  168. inline CLcmP(CL_DcmP(CLcmP(cmP,ITEM)),void)
  169. { CLcmP(defaultCmP,ITEM) = CL_Dcmp;
  170.  return CLcmPcast((cmP? cmP : defaultCmP),void); }
  171.  
  172. #endif
  173.  
  174. #if defined(ITEM_str)
  175.     inline void * CL_Dassign(char *,
  176.         const char *, unsigned)
  177.     { return (void *)0; }
  178. #elif defined(ITEM_TEST_ASSIGN)
  179.     inline void * CL_Dassign(ITEM * D,
  180.         const ITEM * S, unsigned)
  181.     { return (void *) 
  182.     ((*D = *(const ITEM_STRM_BASE *)S)? D : 0); }
  183. #elif defined(ITEM_NO_ASSIGN)
  184.     inline void * CL_Dassign(ITEM *,
  185.         const ITEM *, unsigned)
  186.     { return (void *) 0; }
  187. #elif !defined(ITEM_ASSIGN_DEF)
  188.     inline void * CL_Dassign(ITEM * D,
  189.         const ITEM * S, unsigned)
  190.     { *D = *S; return (void *) D; }
  191. #endif
  192.  
  193. #if defined(ITEM_str)
  194.     inline void * CL_Dnew(const ITEM * D)
  195.     { return strdup(D); }
  196. #elif defined(ITEM_CLONE)
  197.     inline void * CL_Dnew(const ITEM * D)
  198.     { return (void *) D->clone(); }
  199. #elif defined(ITEM_NO_COPYINIT)
  200.     inline void * CL_Dnew(const ITEM *)
  201.     { return (void *) 0; }
  202. #elif !defined(ITEM_COPYINIT_DEF)
  203.     inline void * CL_Dnew(const ITEM * D)
  204.     { return (void *) new ITEM(*D); }
  205. #endif
  206.  
  207. #if defined(ITEM_STRM_MUT_DELETE)
  208.     inline void CL_Ddelete(ITEM * D)
  209.     { if (!D->RefCount()) delete D; }
  210. #elif defined(ITEM_NO_DELETE)
  211.     inline void CL_Ddelete(ITEM *)
  212.     { return; }
  213. #elif !defined(ITEM_DELETE_DEF)
  214.     inline void CL_Ddelete(ITEM *D)
  215.     { delete D; }
  216. #endif
  217.  
  218. #if defined(ITEM_LINK)
  219.     inline int CL_Dattach(ITEM * D,
  220.     const void * B)
  221.     { return D->link(B); }
  222. #elif !defined(ITEM_LINK_DEF)
  223.     inline int CL_Dattach(ITEM *,
  224.     const void *)
  225.     { return 1; }
  226. #endif
  227.  
  228. #if defined(ITEM_UNLINK)
  229.     inline void CL_Ddetach
  230.     (ITEM * D, const void * B)
  231.     { D->unlink(B); }
  232. #elif !defined(ITEM_UNLINK_DEF)
  233.     inline void CL_Ddetach(ITEM*,
  234.     const void *) {}
  235. #endif
  236.  
  237.  
  238. #if defined(ITEM_STRM_INSERT)
  239.     inline ostream& operator<<(ostream& os,
  240.         ITEM ** D)
  241.     { return os << *(ITEM_STRM_BASE *)*D; }
  242. #elif defined(ITEM_NO_STRM_INSERT)
  243.     inline ostream& operator<<(ostream& os,
  244.         ITEM **) { return os; }
  245. #elif defined(ITEM_BINARY_STRM_INSERT)
  246.     inline ostream& operator<<(ostream& os,
  247.         ITEM ** D)
  248.     { return os.write((char *)*D,sizeof(ITEM)); }
  249. #elif !defined(ITEM_STRM_INSERT_DEF) && !defined(ITEM_str)
  250.     inline ostream& operator<<(ostream& os,
  251.         ITEM ** D)
  252.     { return os << **D << endm; }
  253. #endif
  254. inline ostream& operator<<(ostream& os, char ** D)
  255. {
  256.     int len = (*D? strlen(*D) : 0);
  257.     if ((os << len << endm))
  258.         if (len)
  259.             os.write(*D,len);
  260.     return os;
  261. }
  262.  
  263.  
  264. #if defined(ITEM_STRM_EXTRACT)
  265.     inline istream& operator>>(istream& is,
  266.         ITEM ** D)
  267.     {
  268.         ITEM_STRM_BASE * S;
  269.         is >> S;
  270.         if (*D) delete *D;
  271.         *D = (ITEM *) S;
  272.         return is;
  273.     }
  274. #elif defined(ITEM_NO_STRM_EXTRACT)
  275.     inline istream& operator>>(istream& is,
  276.         ITEM **) { return is; }
  277. #elif defined(ITEM_BINARY_STRM_EXTRACT)
  278.         inline istream& operator>>(istream& is,
  279.         ITEM ** D)
  280.     {
  281.      if (*D) delete *D;
  282.      if ((*D = new ITEM) != (ITEM *)0)
  283.       return is.read((char *)*D,sizeof(ITEM));
  284.      return is;
  285.     }
  286. #elif !defined(ITEM_STRM_EXTRACT_DEF) && !defined(ITEM_str)
  287.     inline istream& operator>>(istream& is,
  288.         ITEM ** D)
  289.     {
  290.         if (*D) delete *D;
  291.         if ((*D = new ITEM) != (ITEM *)0)
  292.             is >> **D >> nextm;
  293.         return is;
  294.     }
  295. #endif
  296. inline istream& operator>>(istream& is, char ** D)
  297. {
  298.     int len;
  299.     if (*D)  {
  300.         delete *D;
  301.         *D = (char *)0;
  302.     }
  303.     if ((is >> len >> nextm))
  304.         if (len)
  305.           if ((*D = new char[len+1])
  306.             != (char *)0)  {
  307.             is.read(*D,len);
  308.             (*D)[len] = '\0';
  309.           }
  310.           else
  311.             is.ignore(len);
  312.     return is;
  313. }
  314.  
  315.  
  316. class CL : cl {
  317.  
  318.  
  319. protected:
  320.  
  321.     CL  (defaultConstructor)
  322.             : cl(defaultConstruct) {}
  323.     void     assign(const CL& b)
  324.             { cl::assign(b); }
  325.     cl::     destruct;
  326.     virtual  voidCmP DcmP(voidCmP cmP)
  327.             { return CLcmPcast(CL_DcmP
  328.             (CLcmPcast(cmP,ITEM)),void); }
  329.     virtual  void * Dassign(void * D,
  330.             const void * S)
  331.             { return CL_Dassign
  332.             ((ITEM *)D,(const ITEM *)S,
  333.             flags); }
  334.     virtual  void * Dnew(const void * D)
  335.             { return  CL_Dnew
  336.             ((const ITEM *)D); }
  337.     virtual  void   Ddelete(void * D)
  338.             { CL_Ddelete((ITEM *)D); }
  339.     virtual  int    Dattach(void * D)
  340.             { return CL_Dattach((ITEM *)D,
  341.             (const void *) this); }
  342.     virtual  void   Ddetach(void * D)
  343.             { CL_Ddetach((ITEM *)D,
  344.             (const void *) this); }
  345.     virtual     int    Dput(ostream& os, void * D)
  346.             { return ((os << (ITEM **) &D)?
  347.             1 : 0); }
  348.     virtual     void * Dget(istream& is)
  349.             { ITEM * D = 0; is >> &D;
  350.             return (void *) D; }
  351.     virtual  int    put(ostream& os)
  352.             { return cl::put(os); }
  353.     virtual  int    get(istream& is)
  354.             { return cl::get(is); }
  355.     friend   ostream& operator<<(ostream& os,
  356.             CL& b);
  357.     friend   istream& operator>>(istream& is,
  358.             CL& b);
  359.     cl:: vforEach;
  360.  
  361.  
  362. public:
  363.  
  364. /*  Constructors and destructor  */
  365.  
  366.     CL (unsigned flags = CL_BIND_ONLY,
  367.         unsigned maxNodes = CL_MAXNODES,
  368.         unsigned limit = CL_LIMIT,
  369.         unsigned delta = CL_DELTA) :
  370.         cl(flags,maxNodes,limit,delta)
  371.         {}
  372.     CL (ITEM * argv[],
  373.         unsigned argc = 0U,
  374.         unsigned flags = CL_BIND_ONLY)
  375.         : cl((void **)argv,argc,flags)
  376.         {}
  377.     CL (CL& b) : cl(defaultConstruct)
  378.         { assign(b); }
  379.     CL& operator=(CL& b)
  380.         { assign(b); return *this; }
  381.     int     operator==(const CL& b) const
  382.         { return cl::operator==(b); }
  383.     int     operator> (const CL& b) const
  384.         { return cl::operator>(b); }
  385.     CL (const char * filename)
  386.         : cl(defaultConstruct)
  387.         { (void) cl::load(filename); }
  388.     int     load(const char * filename)
  389.         { return cl::load(filename); }
  390.     int     save(const char * filename)
  391.         { return cl::save(filename); }
  392.     ITEM ** vector(ITEM ** argv = (ITEM **)0,
  393.         unsigned argc = 0U) const
  394.         { return (ITEM **)cl::
  395.         vector((void **)argv,argc); }
  396.     virtual ~CL() { destruct(); }
  397.  
  398.  
  399. /*  Housekeeping Primitives  */
  400.  
  401.     cl::    Limit;
  402.     cl::    setLimit;
  403.     cl::    pack;
  404.     cl::    Delta;
  405.     cl::    setDelta;
  406.     cl::    Nodes;
  407.     cl::    MaxNodes;
  408.     cl::    setMaxNodes;
  409.     cl::    vacancy;
  410.     cl::    vacancyNonElastic;
  411.     cl::    Flags;
  412.     cl::    setFlags;
  413.     cl::    resetFlags;
  414.     CL&     operator<<(CL&
  415.             (*manipulator)(CL&))
  416.             { return (manipulator?
  417.             (*manipulator)
  418.             (*this)    : *this); }
  419.  
  420.  
  421. /*  Elastic Array Primitives  */
  422.  
  423.     ITEM *   atIns(unsigned n, ITEM * D)
  424.             { return (ITEM *)cl::
  425.             atIns(n,(void *)D); }
  426.     ITEM *   atInsNew(unsigned n, const ITEM * D)
  427.             { return (ITEM *)cl::
  428.             atInsNew(n,(const void *)D); }
  429.     ITEM *   atRmv(unsigned n)
  430.             { return (ITEM *)cl::
  431.             atRmv(n); }
  432.     cl::     allRmv;
  433.     cl::     atDel;
  434.     ITEM *   atDelAsg(unsigned n, ITEM * D)
  435.             { return (ITEM *)cl::
  436.             atDelAsg(n,(void *)D); }
  437.     cl::     allDel;
  438.     cl::     allClr;
  439.     ITEM *   atPut(unsigned n, ITEM * D)
  440.             { return (ITEM *)cl::
  441.             atPut(n,(void *)D); }
  442.     ITEM *   atPutNew(unsigned n, const ITEM * D)
  443.             { return (ITEM *)cl::
  444.             atPutNew(n,(const void *)D); }
  445.     ITEM *   atPutAsg(unsigned n, const ITEM * D)
  446.             { return (ITEM *)cl::
  447.             atPutAsg(n,(const void *)D); }
  448.     ITEM *   atGet(unsigned n) const
  449.             { return (ITEM *)cl::
  450.             atGet(n); }
  451.     ITEM *   operator[](unsigned n) const
  452.             { return atGet(n); }
  453.     ITEM *   atGetAsg(unsigned n, ITEM * D)
  454.             { return (ITEM *)cl::
  455.             atGetAsg(n,(void *) D); }
  456.     ITEM *   atXchg(unsigned n, ITEM * D)
  457.             { return (ITEM *)cl::
  458.             atXchg(n,(void *) D); }
  459.     unsigned index(const ITEM * D) const
  460.             { return cl::
  461.             index((const void *)D); }
  462.     void     forEach(CLapplY(B,ITEM), ...)
  463.             { va_list args;
  464.             va_start(args,B);
  465.             vforEach((voidApplY)B,args);
  466.             va_end(args); }
  467.  
  468.  
  469. /*  Stack - Deque - Queue Primitives  */
  470.  
  471.     ITEM *   push(ITEM * D)
  472.             { return (ITEM *)cl::
  473.             push((void *) D); }
  474.     ITEM *   pushNew(const ITEM * D)
  475.             { return (ITEM *)cl::
  476.             pushNew((const void *)D); }
  477.     ITEM *   pop()
  478.             { return (ITEM *)cl::
  479.             pop(); }
  480.     CL&      operator>>(ITEM *& D)
  481.             { D = atRmv(0U);
  482.             return *this; }
  483.     cl::     popDel;
  484.     ITEM *   popDelAsg(ITEM * D)
  485.             { return (ITEM *)cl::
  486.             popDelAsg((void *)D); }
  487.     ITEM *   top() const
  488.             { return (ITEM *)cl::
  489.                 top(); }
  490.     ITEM *   topAsg(ITEM * D)
  491.             { return (ITEM *)cl::
  492.             topAsg((void *)D); }
  493.     ITEM *   insQ(ITEM * D)
  494.             { return (ITEM *)cl::
  495.             insQ((void *)D); }
  496.     CL&      operator<<(ITEM * D)
  497.             { atIns(Nodes(),D);
  498.                    return *this; }
  499.     ITEM *   insQNew(const ITEM * D)
  500.             { return (ITEM *)cl::
  501.             insQNew((const void *)D); }
  502.     ITEM *   unQ()
  503.             { return (ITEM *)cl::
  504.             unQ(); }
  505.     cl::     unQDel;
  506.     ITEM *   unQDelAsg(ITEM * D)
  507.             { return (ITEM *)cl::
  508.             unQDelAsg((void *)D); }
  509.     ITEM *   rear() const
  510.             { return (ITEM *)cl::
  511.                 rear(); }
  512.     ITEM *   rearAsg(ITEM * D)
  513.             { return (ITEM *)cl::
  514.             rearAsg((void *)D); }
  515.  
  516.  
  517. /*  List (single and double linked) Primitives  */
  518.  
  519.     cl::     CurNode;
  520.     cl::     setCurNode;
  521.     ITEM *   ins(ITEM * D)
  522.             { return (ITEM *)cl::
  523.             ins((void *)D); }
  524.     ITEM *   insNew(const ITEM * D)
  525.             { return (ITEM *)cl::
  526.             insNew((const void *)D); }
  527.     ITEM *   rmv()
  528.             { return (ITEM *)cl::
  529.             rmv(); }
  530.     cl::     del;
  531.     ITEM *   delAsg(ITEM * D)
  532.             { return (ITEM *)cl::
  533.             delAsg((void *)D); }
  534.     ITEM *   put(ITEM * D)
  535.             { return (ITEM *)cl::
  536.             put((void *)D); }
  537.     ITEM *   putNew(const ITEM * D)
  538.             { return (ITEM *)cl::
  539.             putNew((const void *)D); }
  540.     ITEM *   putAsg(const ITEM * D)
  541.             { return (ITEM *)cl::
  542.             putAsg((const void *)D); }
  543.     ITEM *   get() const
  544.             { return (ITEM *)cl::
  545.             get(); }
  546.     operator ITEM *() const { return get(); }
  547.     ITEM *   getAsg(ITEM * D)
  548.             { return (ITEM *)cl::
  549.             getAsg((void *)D); }
  550.     ITEM *   next()
  551.             { return (ITEM *)cl::
  552.             next(); }
  553.     ITEM *   operator++()
  554.             { return next(); }
  555.     ITEM *   nextAsg(ITEM * D)
  556.             { return (ITEM *)cl::
  557.             nextAsg((void *)D); }
  558.     ITEM *   prev()
  559.             { return (ITEM *)cl::
  560.             prev(); }
  561.     ITEM *   operator--()
  562.             { return prev(); }
  563.     ITEM *   prevAsg(ITEM * D)
  564.             { return (ITEM *)cl::
  565.             prevAsg((void *)D); }
  566.  
  567.  
  568. /* Priority Q, Set, Bag, Dictionary, Sort Primitives */
  569.  
  570.     cl::     Sorted;
  571.     cl::     unSort;
  572.     void     setCmP(CLcmP(cmP,ITEM)
  573.             = CLcmP0(ITEM))
  574.             { cl::setCmP
  575.             ((voidCmP)cmP); }
  576.     CLcmP(CmPfnc,ITEM) { return CLcmPcast
  577.             (cl::CmP(),ITEM); }
  578.     int      sort(CLcmP(cmP,ITEM)
  579.             = CLcmP0(ITEM))
  580.             { return cl::sort
  581.             ((voidCmP)cmP); }
  582.     ITEM *   insSort(ITEM * D)
  583.             { return (ITEM *)cl::
  584.             insSort((void *)D); }
  585.     ITEM *   insSortNew(const ITEM * D)
  586.             { return (ITEM *)cl::
  587.             insSortNew((const void *)D); }
  588.     ITEM *   insUnique(ITEM * D)
  589.             { return (ITEM *)cl::
  590.             insUnique((void *)D); }
  591.     ITEM *   insUniqueNew(const ITEM * D)
  592.             { return (ITEM *)cl::
  593.             insUniqueNew((const void *)D);}
  594.     ITEM *   findFirst(const ITEM * K)
  595.             { return (ITEM *)cl::
  596.             findFirst((const void *)K); }
  597.     ITEM *   operator[](const ITEM * K)
  598.             { return findFirst(K); }
  599.     ITEM *   findNext(const ITEM * K)
  600.             { return (ITEM *)cl::
  601.             findNext((const void *)K); }
  602.     ITEM *   findLast (const ITEM * K)
  603.             { return (ITEM *)cl::
  604.             findLast((const void *)K); }
  605.     ITEM *   findPrev(const ITEM * K)
  606.             { return (ITEM *)cl::
  607.             findPrev((const void *)K); }
  608.     unsigned findAll(const ITEM * K)
  609.             { return cl::
  610.             findAll((const void *)K); }
  611.  
  612.  
  613. };    /*  class CL  */
  614.  
  615.  
  616. inline ostream& operator<<(ostream& os, CL& b)
  617.     { (void) b.put(os); return os; }
  618.  
  619. inline istream& operator>>(istream& is, CL& b)
  620.     { (void) b.get(is); return is; }
  621.  
  622.  
  623. #undef ITEM
  624. #undef CL
  625.  
  626. #undef ITEM_BINARY_CMP
  627. #undef ITEM_BINARY_STRM_INSERT
  628. #undef ITEM_BINARY_STRM_EXTRACT
  629. #undef ITEM_BINARY_STRM
  630. #undef ITEM_BINARY_CMP_STRM
  631.  
  632. #undef ITEM_CMP_DEF
  633. #undef ITEM_ASSIGN_DEF
  634. #undef ITEM_COPYINIT_DEF
  635. #undef ITEM_DELETE_DEF
  636. #undef ITEM_LINK_DEF
  637. #undef ITEM_UNLINK_DEF
  638. #undef ITEM_STRM_INSERT_DEF
  639. #undef ITEM_STRM_EXTRACT_DEF
  640.  
  641. #undef ITEM_NO_STRM_OPS
  642. #undef ITEM_NO_REL_STRM_OPS
  643. #undef ITEM_DELETE_ONLY
  644.     #undef ITEM_NO_REL_OPS
  645.     #undef ITEM_NO_ASSIGN
  646.     #undef ITEM_NO_COPYINIT
  647.     #undef ITEM_NO_STRM_INSERT
  648.     #undef ITEM_NO_STRM_EXTRACT
  649. #undef ITEM_BIND_ONLY
  650.     #undef ITEM_NO_DELETE
  651. #undef ITEM_STRMABLE
  652.     #undef ITEM_TEST_ASSIGN
  653.     #undef ITEM_CLONE
  654.     #undef ITEM_STRM_MUT_DELETE
  655.     #undef ITEM_LINK
  656.     #undef ITEM_UNLINK
  657.     #undef ITEM_STRM_INSERT
  658.     #undef ITEM_STRM_EXTRACT
  659. #undef ITEM_STRM_BASE
  660.  
  661. #undef ITEM_str
  662.